home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / -archivi / -recent2 / chunky_dev.lha / chunky_dev / Source / chunkyc2p.asm next >
Assembly Source File  |  1998-12-28  |  19KB  |  1,003 lines
  1. ; 100% systemfriendly ChunkyToPlanar converter for use with intuition
  2. ; screens in applications/games/whatever.
  3. ;
  4. ; Coded in 1994 by Morten Eriksen.
  5. ; Reach me through email: mortene@stud.unit.no.
  6. ;
  7. ; A few changes in 1998 by Stephan Rupprecht <stephan.rupprecht@gmx.de>
  8. ; converted absolute addressing to relative one using the stack
  9. ; inlined make_table, removed 68000/010 support
  10. ;
  11. ; Use and modify as you like - give credit where appropriate.
  12. ;
  13. ; Timings on my A1200 with 68EC020 and 32-bit fastram:
  14. ;
  15. ;   Testcase    Dimensions      This routine             C='s WritePixelArray8
  16. ;
  17. ;    1    320x256x5 -    15 frames (0.30 seconds)    33 frames
  18. ;    2    320x256x8 -    16 frames (0.32 seconds)    51 frames
  19. ;    3    640x512x4 -    63 frames (1.26 seconds)    100 frames
  20. ;    4     1024x1024x1 -    194 frames (3.88 seconds)    101 frames
  21. ;    5    752x578x8 -    88 frames (1.76 seconds)    250 frames
  22. ;
  23. ; Please help me speed up this sucker - the main bottleneck is the
  24. ; 'convert32pixels' subroutine (e.g. in the 3rd testcase, 60 out of
  25. ; 63 frames are spent in this routine). As you can see, it gets worse
  26. ; on less bitplanes (compared to C='s routine) - but on 8-bit bitmaps it's
  27. ; about 3 times as fast. If you improve it, be sure to repost the improved
  28. ; version to Usenet, or send it to me through email.
  29. ;
  30. ;------------------------------------------------------------------------------
  31.     xdef    ChunkyToPlanarAsm
  32. ;------------------------------------------------------------------------------
  33. ; This routine takes a buffer of chunkybytes and transform it into
  34. ; planar datas, which are directly inserted into the destination BitMap.
  35. ;
  36. ; As a replacement for C='s WritePixelArray8 routine, this one is on average
  37. ; about twice as fast and works directly on bitmaps (instead of RastPorts).
  38. ; All cases handled (any width and height > 0, no alignment restrictions).
  39. ; Works on OCS/ECS/AGA, all Kickstarts and any MC680x0 CPU.
  40. ; The downside is that it does not do clipping and does not work with
  41. ; interleaved bitmaps (support for interleaved bitmaps should be piece of
  42. ; cake to implement, though).
  43. ;------------------------------------------------------------------------------
  44. ;
  45. ; C interface:
  46. ;
  47. ; extern void __asm ChunkyToPlanarAsm(register __a0 struct c2pStruct *);
  48. ;
  49. ; struct c2pStruct
  50. ; {
  51. ;  struct BitMap *bmap;
  52. ;  UWORD startX, startY, width, height;
  53. ;  UBYTE *chunkybuffer;
  54. ; } c2p;
  55. ;
  56. ; c2p.bmap = mybitmap;
  57. ; c2p.startX = x0;
  58. ; c2p.startY = y0;
  59. ; c2p.width = x1 - x0 + 1;
  60. ; c2p.height = y1 - y0 + 1;
  61. ; c2p.chunkybuffer = chunkybytes;
  62. ;
  63. ; ChunkyToPlanarAsm(&c2p);
  64. ; CopySBitMap(mywindow->RPort->Layer);
  65. ;------------------------------------------------------------------------------
  66. ;
  67. ; Assembler interface:
  68. ;
  69. ; In:     a0 - c2p struct.
  70. ; Out:    Nothing.
  71. ;------------------------------------------------------------------------------
  72.  
  73. ; ** BitMap struct **
  74. BytesPerRow    EQU    0    ; UWORD
  75. Rows        EQU    2    ; UWORD
  76. Flags        EQU    4    ; UBYTE
  77. Depth        EQU    5    ; UBYTE
  78. Pad        EQU    6    ; UWORD
  79. Planes        EQU    8    ; PLANEPTRs [8]
  80.  
  81. ; ** c2p struct **
  82.  
  83. bmap        EQU    0    ; struct BitMap *
  84. startX        EQU    4    ; UWORD
  85. startY        EQU    6    ; UWORD
  86. width        EQU    8    ; UWORD
  87. height        EQU    10    ; UWORD
  88. chunkybuffer    EQU    12    ; UBYTE *
  89.  
  90. ;**
  91.  
  92. buffer            EQU    0
  93. Height            EQU    32
  94. Modulo            EQU    34
  95. GWidth            EQU    36
  96. depth            EQU    38
  97. Width            EQU    40
  98. leadingbits        EQU    42
  99. trailingbits        EQU    44
  100. andval_lead        EQU    46
  101. andval_trail        EQU    47
  102. andval_single        EQU    48
  103. dummy            EQU    49
  104. insertpointer        EQU    50
  105. insertpointerlong    EQU    54
  106. planepointerspointer    EQU    58
  107. sizeof_buffer        EQU    62
  108. ;------------------------------------------------------------------------------
  109.     Section    code,CODE
  110.     
  111. ChunkyToPlanarAsm:
  112.     movem.l    d2-d7/a2-a6,-(sp)
  113.  
  114.     lea.l    -sizeof_buffer(sp),sp
  115.  
  116.     lea.l    made_table(pc),a2
  117.     tst.b    (a2)            * need only make bitspreadtable once
  118.     bne.s    table_made
  119.  
  120. * makes the bitspread table *
  121. * Do not destroy a0! *
  122. make_table:
  123.     lea    c2p,a1
  124.     moveq    #0,d0
  125. more_table
  126.     move.b    d0,d1
  127.  
  128.     moveq    #8-1,d2
  129. byteloop
  130.     btst    #0,d1
  131.     beq.s    zero
  132.     move.b    #1,(a1)+
  133.     bra.s    one
  134. zero    clr.b    (a1)+
  135. one    lsr.b    #1,d1
  136.     dbra    d2,byteloop
  137.  
  138.     addq    #1,d0
  139.     cmp.w    #256,d0
  140.     beq.s    table_done
  141.     bra.s    more_table
  142.  
  143. made_table    dc.w    0
  144.  
  145. table_done
  146.     move.b    #1,(a2)
  147.  
  148. table_made
  149.  
  150.     * find number of not bytealigned pixels at left side of frame and
  151.     * the mask to be used
  152.     moveq    #0,d0
  153.     move.w    startX(a0),d0
  154.     andi.w    #%111,d0
  155.     tst.w    d0
  156.     beq.s    leadno
  157.     move.w    d0,d1
  158.     moveq    #8,d0
  159.     sub.w    d1,d0
  160.  
  161.     move.b    #$ff,d1
  162.     lsl.b    d0,d1
  163.     move.b    d1,andval_lead(sp)
  164.  
  165. leadno    move.w    d0,leadingbits(sp)
  166.  
  167.     move.w    width(a0),d0
  168.     cmp.w    leadingbits(sp),d0
  169.     bhs.s    notsingle
  170.  
  171.     * in case the whole chunkypixels buffer to be inserted fits into
  172.     * a single byte
  173.     move.b    #$80,d1
  174.     subq    #1,d0
  175.     asr.b    d0,d1
  176.     addq    #1,d0
  177.     moveq    #8,d2
  178.     sub.w    leadingbits(sp),d2
  179.     lsr.b    d2,d1
  180.     not.b    d1
  181.     move.b    d1,andval_single(sp)
  182.     clr.w    trailingbits(sp)
  183.     bra.s    single
  184. notsingle
  185.     clr.b    andval_single(sp)
  186.  
  187.     * find number of not bytealigned pixels at right side of frame and
  188.     * the mask to be used
  189.     sub.w    leadingbits(sp),d0
  190.     move.w    d0,d1
  191.     andi.w    #$fff8,d1
  192.     sub.w    d1,d0
  193.     move.w    d0,trailingbits(sp)
  194.     move.b    #$ff,d1
  195.     lsr.b    d0,d1
  196.     move.b    d1,andval_trail(sp)
  197. single
  198.     * initialize variables to be used (modulo, bytealigned width, etc)
  199.     move.l    bmap(a0),a1
  200.     move.l    chunkybuffer(a0),a3
  201.     moveq    #0,d0
  202.     move.b    Depth(a1),d0
  203.     move.w    d0,depth(sp)
  204.     move.w    height(a0),Height(sp)
  205.     move.w    width(a0),Width(sp)
  206.     move.w    leadingbits(sp),d1
  207.     sub.w    d1,Width(sp)
  208.     move.w    trailingbits(sp),d1
  209.     sub.w    d1,Width(sp)
  210.     move.w    Width(sp),GWidth(sp)
  211.     move.w    BytesPerRow(a1),Modulo(sp)
  212.     tst.b    andval_single(sp)
  213.     bne.s    singlebyte
  214.     move.w    Width(sp),d0
  215.     lsr.w    #3,d0
  216.     sub.w    d0,Modulo(sp)
  217. singlebyte
  218.     tst.w    leadingbits(sp)
  219.     beq.s    nolead
  220.     sub.w    #1,Modulo(sp)
  221. nolead    tst.w    trailingbits(sp)
  222.     beq.s    notrail
  223.     sub.w    #1,Modulo(sp)
  224. notrail
  225.  
  226.     * find initial offset in bytes into bitmap given by (startX, startY)
  227.     moveq    #0,d0
  228.     move.w    startX(a0),d0
  229.     lsr.w    #3,d0
  230.     move.w    startY(a0),d1
  231.     tst.w    d1
  232.     beq.s    line0
  233.     moveq    #0,d2
  234.     move.w    BytesPerRow(a1),d2
  235.     subq    #1,d1
  236. makeoffset
  237.     add.l    d2,d0
  238.     dbra    d1,makeoffset
  239. line0
  240.     move.l    d0,a2
  241.  
  242.     * find jumpaddress for planar data insertion into bitmap
  243.     * (depending on bitmap depth)
  244.     move.l    a1,a6
  245.     add.l    #Planes,a6
  246.     lea    insertpointerslong(pc),a4
  247.     lea    insertpointers(pc),a5
  248.     moveq    #0,d7
  249.     move.w    depth(sp),d7
  250.     lsl.w    #2,d7
  251.     add.l    d7,a6
  252.     move.l    a6,planepointerspointer(sp)
  253.     subq    #4,d7
  254.     add.l    d7,a4
  255.     add.l    d7,a5
  256.     move.l    (a4),insertpointerlong(sp)
  257.     move.l    (a5),insertpointer(sp)
  258.  
  259.     lea    c2p,a4
  260.  
  261.     ; a0 - c2p struct, a1 - bmap,
  262.     ; a2 - offset from Planes pointer, a3 - chunkybuffer
  263.     ; a4 - bitspread table
  264.  
  265. convertlines
  266.     * check if whole width fits into a single byte and take
  267.     * appropriate action if this is the case
  268.     tst.b    andval_single(sp)
  269.     beq.s    testlead
  270.     bsr.w    insertsinglebytebits
  271.     bra.w    trailno
  272.  
  273. testlead
  274.     * is the frame _not_ left bytealigned ?
  275.     tst.w    leadingbits(sp)
  276.     beq.b    convert8pixels
  277.     bsr.w    insertleadingbits
  278.  
  279. convert8pixels
  280.     * done?
  281.     tst.w    Width(sp)
  282.     beq.s    rowdone
  283.  
  284.     * check if we can do a speedier 32 pixels in one go conversion...
  285.     cmp.w    #32,Width(sp)
  286.     blo.s    nolong
  287.     * test odd/even address to be compatible with 68000 aswell *
  288. ;    move.l    Planes(a1),d0
  289. ;    add.l    a2,d0
  290. ;    btst    #0,d0
  291. ;    bne.s    nolong
  292.     bsr.w    convert32pixels
  293.     sub.w    #32,Width(sp)
  294.     addq    #4,a2
  295.     bra.s    convert8pixels
  296.  
  297. nolong    * ...rather than the slower 8 pixel conversion
  298.     moveq    #0,d0
  299.     moveq    #0,d4
  300.     moveq    #8-1,d1
  301. convert8bytes
  302.     * find correct bitspreadtable offset -> a4 *
  303.     moveq    #0,d2
  304.     move.b    (a3)+,d2
  305.     lsl.w    #3,d2
  306.  
  307.     * insert bitrow *
  308.     add.l    d0,d0
  309.     or.l    0(a4,d2.w),d0
  310.     addq    #4,d2
  311.     add.l    d4,d4
  312.     or.l    0(a4,d2.w),d4
  313.  
  314.     dbra    d1,convert8bytes
  315.  
  316.     * spread bits to all registers *
  317.     move.b    d0,d3
  318.     lsr.w    #8,d0
  319.     move.b    d0,d2
  320.     swap    d0
  321.     move.b    d0,d1
  322.     lsr.w    #8,d0
  323.  
  324.     move.b    d4,d7
  325.     lsr.w    #8,d4
  326.     move.b    d4,d6
  327.     swap    d4
  328.     move.b    d4,d5
  329.     lsr.w    #8,d4
  330.  
  331.     cmp.w    #8,depth(sp)
  332.     beq.s    its8
  333.     move.l    a2,d7
  334. its8    move.l    planepointerspointer(sp),a6
  335.     move.l    insertpointer(sp),a5
  336.     jsr    (a5)
  337.  
  338.     addq    #1,a2
  339.     subq    #8,Width(sp)
  340.     bra.w    convert8pixels
  341.  
  342. rowdone
  343.     * are there any non bytealigned pixels remaining at the right side
  344.     * of the frame?
  345.     tst.w    trailingbits(sp)
  346.     beq.b    trailno
  347.     bsr.w    inserttrailingbits
  348.  
  349. trailno    move.w    GWidth(sp),Width(sp)
  350.     add.w    Modulo(sp),a2
  351.     subq    #1,Height(sp)
  352.     tst.w    Height(sp)
  353.     bne.w    convertlines
  354.  
  355.     lea.l    sizeof_buffer(sp),sp
  356.  
  357.     movem.l    (sp)+,d2-d7/a2-a6
  358.     rts
  359. ;------------------------------------------------------------------------------
  360. insertdata:    * insert converted 8 pixels c->p data into the bitmap
  361. plane8    move.l    -(a6),a5
  362.     add.l    a2,a5
  363.     move.b    d7,(a5)
  364.     move.l    a2,d7
  365. plane7    move.l    -(a6),a5
  366.     move.b    d6,0(a5,d7.l)
  367. plane6    move.l    -(a6),a5
  368.     move.b    d5,0(a5,d7.l)
  369. plane5    move.l    -(a6),a5
  370.     move.b    d4,0(a5,d7.l)
  371. plane4    move.l    -(a6),a5
  372.     move.b    d3,0(a5,d7.l)
  373. plane3    move.l    -(a6),a5
  374.     move.b    d2,0(a5,d7.l)
  375. plane2    move.l    -(a6),a5
  376.     move.b    d1,0(a5,d7.l)
  377. plane1    move.l    -(a6),a5
  378.     move.b    d0,0(a5,d7.l)
  379.     rts
  380. ;------------------------------------------------------------------------------
  381. insertdatalong:    * insert converted 32 pixels c->p data into the bitmap
  382. plane8l    move.l    -(a6),a5
  383.     add.l    a2,a5
  384.     move.l    d7,(a5)
  385.     move.l    a2,d7
  386. plane7l    move.l    -(a6),a5
  387.     move.l    d6,0(a5,d7.l)
  388. plane6l    move.l    -(a6),a5
  389.     move.l    d5,0(a5,d7.l)
  390. plane5l    move.l    -(a6),a5
  391.     move.l    d4,0(a5,d7.l)
  392. plane4l    move.l    -(a6),a5
  393.     move.l    d3,0(a5,d7.l)
  394. plane3l    move.l    -(a6),a5
  395.     move.l    d2,0(a5,d7.l)
  396. plane2l    move.l    -(a6),a5
  397.     move.l    d1,0(a5,d7.l)
  398. plane1l    move.l    -(a6),a5
  399.     move.l    d0,0(a5,d7.l)
  400.     rts
  401. ;------------------------------------------------------------------------------
  402. convert32pixels:
  403.     * convert 4 * 8 = 32 pixels in one go
  404.     lea    buffer+32+4(sp),a5
  405.  
  406.     moveq    #4-1,d3
  407. eachlong
  408.     moveq    #0,d2
  409.     move.b    (a3)+,d2
  410.     lsl.w    #3,d2
  411.     movem.l    0(a4,d2.w),d0/d4
  412.  
  413.     moveq    #0,d2
  414.     move.b    (a3)+,d2
  415.     lsl.w    #3,d2
  416.     add.l    d0,d0
  417.     or.l    0(a4,d2.w),d0
  418.     add.l    d4,d4
  419.     or.l    4(a4,d2.w),d4
  420.  
  421.     moveq    #0,d2
  422.     move.b    (a3)+,d2
  423.     lsl.w    #3,d2
  424.     add.l    d0,d0
  425.     or.l    0(a4,d2.w),d0
  426.     add.l    d4,d4
  427.     or.l    4(a4,d2.w),d4
  428.  
  429.     moveq    #0,d2
  430.     move.b    (a3)+,d2
  431.     lsl.w    #3,d2
  432.     add.l    d0,d0
  433.     or.l    0(a4,d2.w),d0
  434.     add.l    d4,d4
  435.     or.l    4(a4,d2.w),d4
  436.  
  437.     moveq    #0,d2
  438.     move.b    (a3)+,d2
  439.     lsl.w    #3,d2
  440.     add.l    d0,d0
  441.     or.l    0(a4,d2.w),d0
  442.     add.l    d4,d4
  443.     or.l    4(a4,d2.w),d4
  444.  
  445.     moveq    #0,d2
  446.     move.b    (a3)+,d2
  447.     lsl.w    #3,d2
  448.     add.l    d0,d0
  449.     or.l    0(a4,d2.w),d0
  450.     add.l    d4,d4
  451.     or.l    4(a4,d2.w),d4
  452.  
  453.     moveq    #0,d2
  454.     move.b    (a3)+,d2
  455.     lsl.w    #3,d2
  456.     add.l    d0,d0
  457.     or.l    0(a4,d2.w),d0
  458.     add.l    d4,d4
  459.     or.l    4(a4,d2.w),d4
  460.  
  461.     moveq    #0,d2
  462.     move.b    (a3)+,d2
  463.     lsl.w    #3,d2
  464.     add.l    d0,d0
  465.     or.l    0(a4,d2.w),d0
  466.     add.l    d4,d4
  467.     or.l    4(a4,d2.w),d4
  468.  
  469.     * push temporary converted data in buffer
  470.     movem.l    d0/d4,-(a5)
  471.     dbra    d3,eachlong
  472.  
  473.     * buffer now looks like this:
  474.     * d00 d10
  475.     * d20 d30
  476.     * d40 d50
  477.     * d60 d70
  478.     * d01 d11
  479.     * d21 d31
  480.     * d41 d51
  481.     * d61 d71
  482.     * d02 d12
  483.     * d22 d32
  484.     * d42 d52
  485.     * d62 d72
  486.     * d03 d13
  487.     * d23 d33
  488.     * d43 d53
  489.     * d63 d73
  490.     * ...where e.g. d43 means most significant byte (#3) in dataregister 4
  491.  
  492.     * now pop the converted data from the buffer and into the
  493.     * dataregisters
  494.     add.l    #4*2*4,a5
  495.  
  496.     move.l    -(a5),d4
  497.     move.b    d4,d7
  498.     lsr.w    #8,d4
  499.     move.b    d4,d6
  500.     swap    d4
  501.     move.b    d4,d5
  502.     lsr.w    #8,d4
  503.  
  504.     move.l    -(a5),d0
  505.     move.b    d0,d3
  506.     lsr.w    #8,d0
  507.     move.b    d0,d2
  508.     swap    d0
  509.     move.b    d0,d1
  510.     lsr.w    #8,d0
  511.  
  512.     lsl.w    #8,d7
  513.     move.b    -1(a5),d7
  514.     lsl.w    #8,d6
  515.     move.b    -2(a5),d6
  516.     lsl.w    #8,d5
  517.     move.b    -3(a5),d5
  518.     lsl.w    #8,d4
  519.     move.b    -4(a5),d4
  520.     lsl.w    #8,d3
  521.     move.b    -5(a5),d3
  522.     lsl.w    #8,d2
  523.     move.b    -6(a5),d2
  524.     lsl.w    #8,d1
  525.     move.b    -7(a5),d1
  526.     lsl.w    #8,d0
  527.     move.b    -8(a5),d0
  528.  
  529.     swap    d0
  530.     swap    d1
  531.     swap    d2
  532.     swap    d3
  533.     swap    d4
  534.     swap    d5
  535.     swap    d6
  536.     swap    d7
  537.  
  538.     subq    #8,a5
  539.  
  540.     move.w    -(a5),d6
  541.     move.b    d6,d7
  542.     lsr.w    #8,d6
  543.     move.w    -(a5),d4
  544.     move.b    d4,d5
  545.     lsr.w    #8,d4
  546.     move.w    -(a5),d2
  547.     move.b    d2,d3
  548.     lsr.w    #8,d2
  549.     move.w    -(a5),d0
  550.     move.b    d0,d1
  551.     lsr.w    #8,d0
  552.  
  553.     lsl.w    #8,d7
  554.     move.b    -1(a5),d7
  555.     lsl.w    #8,d6
  556.     move.b    -2(a5),d6
  557.     lsl.w    #8,d5
  558.     move.b    -3(a5),d5
  559.     lsl.w    #8,d4
  560.     move.b    -4(a5),d4
  561.     lsl.w    #8,d3
  562.     move.b    -5(a5),d3
  563.     lsl.w    #8,d2
  564.     move.b    -6(a5),d2
  565.     lsl.w    #8,d1
  566.     move.b    -7(a5),d1
  567.     lsl.w    #8,d0
  568.     move.b    -8(a5),d0
  569.  
  570.     * insert the converted c->p data into the bitmap
  571.     cmp.w    #8,depth+4(sp)
  572.     beq.b    its8x
  573.     move.l    a2,d7
  574. its8x    move.l    planepointerspointer+4(sp),a6
  575.     move.l    insertpointerlong+4(sp),a5
  576.     jsr    (a5)
  577.     rts
  578. ;------------------------------------------------------------------------------
  579. insertleadingbits:
  580.     moveq    #0,d0
  581.     moveq    #0,d4
  582.     move.w    leadingbits+4(sp),d1
  583.     subq    #1,d1
  584. convertleadingbits
  585.     * find correct bitspreadtable offset -> a4 *
  586.     moveq    #0,d2
  587.     move.b    (a3)+,d2
  588.     lsl.w    #3,d2
  589.  
  590.     * insert bitrow *
  591.     add.l    d0,d0
  592.     or.l    0(a4,d2.w),d0
  593.     addq    #4,d2
  594.     add.l    d4,d4
  595.     or.l    0(a4,d2.w),d4
  596.  
  597.     dbra    d1,convertleadingbits
  598.  
  599.     * spread bits to all registers *
  600.     move.b    d0,d3
  601.     lsr.w    #8,d0
  602.     move.b    d0,d2
  603.     swap    d0
  604.     move.b    d0,d1
  605.     lsr.w    #8,d0
  606.  
  607.     move.b    d4,d7
  608.     lsr.w    #8,d4
  609.     move.b    d4,d6
  610.     swap    d4
  611.     move.b    d4,d5
  612.     lsr.w    #8,d4
  613.  
  614.     movem.l    a0-a1/a3/a5,-(sp)
  615.  
  616.     move.w    depth+4+4*4(sp),a0
  617.     addq    #Planes,a1
  618.  
  619.     * read and mix in the data from the bitmap with the converted data
  620. planel0    move.w    d7,a5
  621.     move.l    (a1),a3
  622.     add.l    a2,a3
  623.     move.b    (a3),d7
  624.     and.b    andval_lead+4+4*4(sp),d7
  625.     or.b    d7,d0
  626.     move.w    a5,d7
  627.     move.w    d0,a5
  628.  
  629.     subq    #1,a0
  630.     cmp.w    #0,a0
  631.     beq.w    doneplanes
  632. planel1    addq    #4,a1
  633.     move.l    (a1),a3
  634.     add.l    a2,a3
  635.     move.b    (a3),d0
  636.     and.b    andval_lead+4+4*4(sp),d0
  637.     or.b    d0,d1
  638.  
  639.     subq    #1,a0
  640.     cmp.w    #0,a0
  641.     beq.w    doneplanes
  642. planel2    addq    #4,a1
  643.     move.l    (a1),a3
  644.     add.l    a2,a3
  645.     move.b    (a3),d0
  646.     and.b    andval_lead+4+4*4(sp),d0
  647.     or.b    d0,d2
  648.  
  649.     subq    #1,a0
  650.     cmp.w    #0,a0
  651.     beq.s    doneplanes
  652. planel3    addq    #4,a1
  653.     move.l    (a1),a3
  654.     add.l    a2,a3
  655.     move.b    (a3),d0
  656.     and.b    andval_lead+4+4*4(sp),d0
  657.     or.b    d0,d3
  658.  
  659.     subq    #1,a0
  660.     cmp.w    #0,a0
  661.     beq.s    doneplanes
  662. planel4    addq    #4,a1
  663.     move.l    (a1),a3
  664.     add.l    a2,a3
  665.     move.b    (a3),d0
  666.     and.b    andval_lead+4+4*4(sp),d0
  667.     or.b    d0,d4
  668.  
  669.     subq    #1,a0
  670.     cmp.w    #0,a0
  671.     beq.s    doneplanes
  672. planel5    addq    #4,a1
  673.     move.l    (a1),a3
  674.     add.l    a2,a3
  675.     move.b    (a3),d0
  676.     and.b    andval_lead+4+4*4(sp),d0
  677.     or.b    d0,d5
  678.  
  679.     subq    #1,a0
  680.     cmp.w    #0,a0
  681.     beq.s    doneplanes
  682. planel6    addq    #4,a1
  683.     move.l    (a1),a3
  684.     add.l    a2,a3
  685.     move.b    (a3),d0
  686.     and.b    andval_lead+4+4*4(sp),d0
  687.     or.b    d0,d6
  688.  
  689.     subq    #1,a0
  690.     cmp.w    #0,a0
  691.     beq.s    doneplanes
  692. planel7    addq    #4,a1
  693.     move.l    (a1),a3
  694.     add.l    a2,a3
  695.     move.b    (a3),d0
  696.     and.b    andval_lead+4+4*4(sp),d0
  697.     or.b    d0,d7
  698.  
  699. doneplanes
  700.     move.w    a5,d0
  701.     movem.l    (sp)+,a0-a1/a3/a5
  702.     
  703.     cmp.w    #8,depth+4(sp)
  704.     beq.s    its8l
  705.     move.l    a2,d7
  706. its8l    move.l    planepointerspointer+4(sp),a6
  707.     move.l    insertpointer+4(sp),a5
  708.     jsr    (a5)
  709.     addq    #1,a2
  710.     rts
  711. ;------------------------------------------------------------------------------
  712. inserttrailingbits:
  713.     moveq    #0,d0
  714.     moveq    #0,d4
  715.     move.w    trailingbits+4(sp),d1
  716.     subq    #1,d1
  717. converttrailingbits
  718.     * find correct bitspreadtable offset -> a4 *
  719.     moveq    #0,d2
  720.     move.b    (a3)+,d2
  721.     lsl.w    #3,d2
  722.  
  723.     * insert bitrow *
  724.     add.l    d0,d0
  725.     or.l    0(a4,d2.w),d0
  726.     addq    #4,d2
  727.     add.l    d4,d4
  728.     or.l    0(a4,d2.w),d4
  729.  
  730.     dbra    d1,converttrailingbits
  731.  
  732.     moveq    #8,d1
  733.     sub.w    trailingbits+4(sp),d1
  734.     lsl.l    d1,d0
  735.     lsl.l    d1,d4
  736.     
  737.     * spread bits to all registers *
  738.     move.b    d0,d3
  739.     lsr.w    #8,d0
  740.     move.b    d0,d2
  741.     swap    d0
  742.     move.b    d0,d1
  743.     lsr.w    #8,d0
  744.  
  745.     move.b    d4,d7
  746.     lsr.w    #8,d4
  747.     move.b    d4,d6
  748.     swap    d4
  749.     move.b    d4,d5
  750.     lsr.w    #8,d4
  751.  
  752.     movem.l    a0-a1/a3/a5,-(sp)
  753.  
  754.     move.w    depth+4+4*4(sp),a0
  755.     addq    #Planes,a1
  756.  
  757.     * read and mix in the data from the bitmap with the converted data
  758. planet0    move.w    d7,a5
  759.     move.l    (a1),a3
  760.     add.l    a2,a3
  761.     move.b    (a3),d7
  762.     and.b    andval_trail+4+4*4(sp),d7
  763.     or.b    d7,d0
  764.     move.w    a5,d7
  765.     move.w    d0,a5
  766.  
  767.     subq    #1,a0
  768.     cmp.w    #0,a0
  769.     beq.w    done_planes
  770. planet1    addq    #4,a1
  771.     move.l    (a1),a3
  772.     add.l    a2,a3
  773.     move.b    (a3),d0
  774.     and.b    andval_trail+4+4*4(sp),d0
  775.     or.b    d0,d1
  776.  
  777.     subq    #1,a0
  778.     cmp.w    #0,a0
  779.     beq.w    done_planes
  780. planet2    addq    #4,a1
  781.     move.l    (a1),a3
  782.     add.l    a2,a3
  783.     move.b    (a3),d0
  784.     and.b    andval_trail+4+4*4(sp),d0
  785.     or.b    d0,d2
  786.  
  787.     subq    #1,a0
  788.     cmp.w    #0,a0
  789.     beq.s    done_planes
  790. planet3    addq    #4,a1
  791.     move.l    (a1),a3
  792.     add.l    a2,a3
  793.     move.b    (a3),d0
  794.     and.b    andval_trail+4+4*4(sp),d0
  795.     or.b    d0,d3
  796.  
  797.     subq    #1,a0
  798.     cmp.w    #0,a0
  799.     beq.s    done_planes
  800. planet4    addq    #4,a1
  801.     move.l    (a1),a3
  802.     add.l    a2,a3
  803.     move.b    (a3),d0
  804.     and.b    andval_trail+4+4*4(sp),d0
  805.     or.b    d0,d4
  806.  
  807.     subq    #1,a0
  808.     cmp.w    #0,a0
  809.     beq.s    done_planes
  810. planet5    addq    #4,a1
  811.     move.l    (a1),a3
  812.     add.l    a2,a3
  813.     move.b    (a3),d0
  814.     and.b    andval_trail+4+4*4(sp),d0
  815.     or.b    d0,d5
  816.  
  817.     subq    #1,a0
  818.     cmp.w    #0,a0
  819.     beq.s    done_planes
  820. planet6    addq    #4,a1
  821.     move.l    (a1),a3
  822.     add.l    a2,a3
  823.     move.b    (a3),d0
  824.     and.b    andval_trail+4+4*4(sp),d0
  825.     or.b    d0,d6
  826.  
  827.     subq    #1,a0
  828.     cmp.w    #0,a0
  829.     beq.s    done_planes
  830. planet7    addq    #4,a1
  831.     move.l    (a1),a3
  832.     add.l    a2,a3
  833.     move.b    (a3),d0
  834.     and.b    andval_trail+4+4*4(sp),d0
  835.     or.b    d0,d7
  836.  
  837. done_planes
  838.     move.w    a5,d0
  839.     movem.l    (sp)+,a0-a1/a3/a5
  840.     
  841.     cmp.w    #8,depth+4(sp)
  842.     beq.s    its8t
  843.     move.l    a2,d7
  844. its8t    move.l    planepointerspointer+4(sp),a6
  845.     move.l    insertpointer+4(sp),a5
  846.     jsr    (a5)
  847.     addq    #1,a2
  848.     rts
  849. ;------------------------------------------------------------------------------
  850. insertsinglebytebits:
  851.     moveq    #0,d0
  852.     moveq    #0,d4
  853.     move.w    width(a0),d1
  854.     subq    #1,d1
  855. convertsinglebytebits
  856.     * find correct bitspreadtable offset -> a4 *
  857.     moveq    #0,d2
  858.     move.b    (a3)+,d2
  859.     lsl.w    #3,d2
  860.  
  861.     * insert bitrow *
  862.     add.l    d0,d0
  863.     or.l    0(a4,d2.w),d0
  864.     addq    #4,d2
  865.     add.l    d4,d4
  866.     or.l    0(a4,d2.w),d4
  867.  
  868.     dbra    d1,convertsinglebytebits
  869.  
  870.     moveq    #0,d1
  871.     move.w    leadingbits+4(sp),d1
  872.     sub.w    width(a0),d1
  873.     lsl.l    d1,d0
  874.     lsl.l    d1,d4
  875.     
  876.     * spread bits to all registers *
  877.     move.b    d0,d3
  878.     lsr.w    #8,d0
  879.     move.b    d0,d2
  880.     swap    d0
  881.     move.b    d0,d1
  882.     lsr.w    #8,d0
  883.  
  884.     move.b    d4,d7
  885.     lsr.w    #8,d4
  886.     move.b    d4,d6
  887.     swap    d4
  888.     move.b    d4,d5
  889.     lsr.w    #8,d4
  890.  
  891.     movem.l    a0-a1/a3/a5,-(sp)
  892.  
  893.     move.w    depth+4+4*4(sp),a0
  894.     addq    #Planes,a1
  895.  
  896.     * read and mix in the data from the bitmap with the converted data
  897. planes0    move.w    d7,a5
  898.     move.l    (a1),a3
  899.     add.l    a2,a3
  900.     move.b    (a3),d7
  901.     and.b    andval_single+4+4*4(sp),d7
  902.     or.b    d7,d0
  903.     move.w    a5,d7
  904.     move.w    d0,a5
  905.  
  906.     subq    #1,a0
  907.     cmp.w    #0,a0
  908.     beq.w    done__planes
  909. planes1    addq    #4,a1
  910.     move.l    (a1),a3
  911.     add.l    a2,a3
  912.     move.b    (a3),d0
  913.     and.b    andval_single+4+4*4(sp),d0
  914.     or.b    d0,d1
  915.  
  916.     subq    #1,a0
  917.     cmp.w    #0,a0
  918.     beq.w    done__planes
  919. planes2    addq    #4,a1
  920.     move.l    (a1),a3
  921.     add.l    a2,a3
  922.     move.b    (a3),d0
  923.     and.b    andval_single+4+4*4(sp),d0
  924.     or.b    d0,d2
  925.  
  926.     subq    #1,a0
  927.     cmp.w    #0,a0
  928.     beq.s    done__planes
  929. planes3    addq    #4,a1
  930.     move.l    (a1),a3
  931.     add.l    a2,a3
  932.     move.b    (a3),d0
  933.     and.b    andval_single+4+4*4(sp),d0
  934.     or.b    d0,d3
  935.  
  936.     subq    #1,a0
  937.     cmp.w    #0,a0
  938.     beq.s    done__planes
  939. planes4    addq    #4,a1
  940.     move.l    (a1),a3
  941.     add.l    a2,a3
  942.     move.b    (a3),d0
  943.     and.b    andval_single+4+4*4(sp),d0
  944.     or.b    d0,d4
  945.  
  946.     subq    #1,a0
  947.     cmp.w    #0,a0
  948.     beq.s    done__planes
  949. planes5    addq    #4,a1
  950.     move.l    (a1),a3
  951.     add.l    a2,a3
  952.     move.b    (a3),d0
  953.     and.b    andval_single+4+4*4(sp),d0
  954.     or.b    d0,d5
  955.  
  956.     subq    #1,a0
  957.     cmp.w    #0,a0
  958.     beq.s    done__planes
  959. planes6    addq    #4,a1
  960.     move.l    (a1),a3
  961.     add.l    a2,a3
  962.     move.b    (a3),d0
  963.     and.b    andval_single+4+4*4(sp),d0
  964.     or.b    d0,d6
  965.  
  966.     subq    #1,a0
  967.     cmp.w    #0,a0
  968.     beq.s    done__planes
  969. planes7    addq    #4,a1
  970.     move.l    (a1),a3
  971.     add.l    a2,a3
  972.     move.b    (a3),d0
  973.     and.b    andval_single+4+4*4(sp),d0
  974.     or.b    d0,d7
  975.  
  976. done__planes
  977.     move.w    a5,d0
  978.     movem.l    (sp)+,a0-a1/a3/a5
  979.     
  980.     cmp.w    #8,depth+4(sp)
  981.     beq.s    its8s
  982.     move.l    a2,d7
  983. its8s    move.l    planepointerspointer+4(sp),a6
  984.     move.l    insertpointer+4(sp),a5
  985.     jsr    (a5)
  986.     addq    #1,a2
  987.     rts
  988.  
  989. ;------------------------------------------------------------------------------
  990.  
  991. insertpointers
  992.     dc.l    plane1,plane2,plane3,plane4,plane5,plane6,plane7,plane8
  993. insertpointerslong
  994.     dc.l    plane1l,plane2l,plane3l,plane4l,plane5l,plane6l,plane7l,plane8l
  995. ;------------------------------------------------------------------------------
  996.  
  997.     Section    tables,BSS    
  998.  
  999. * bitspread table *
  1000. c2p    ds.b    256*8
  1001. ;------------------------------------------------------------------------------
  1002.     END
  1003.